<html>
	<head>
		<style type="text/css">
			/* <![CDATA[ */ 
			@import "http://www.tigris.org/branding/css/tigris.css"; 
			@import "http://www.tigris.org/branding/css/inst.css"; 
			/*  ]]> */
		</style>
		<link rel="stylesheet" type="text/css" href="http://www.tigris.org/branding/css/print.css" media="print" />
		<script src="http://www.tigris.org/branding/scripts/tigris.js" type="text/javascript"/>
		<title>Atlas Project Overview</title>
	</head>
	
	<body>
		<div class="h2 app" style="border-left: 0px" id="customcontent">
			<h2>MDA Concept</h2>
			<p>
				MDA is a methodology wherein system functionality is defined as a platform-independent model (PIM), using an appropriate specification language and then translated to one or more platform-specific models (PSM) for the actual implementation.
			</p>
			<p>
				Development using the MDA approach requires developers to operate at a higher level of abstraction than they may be used to.  Historically, 
				designers produce a model (if you're lucky) prior to development.  Done properly, this has two flavors:	the analysis model which is 
				implementation agnostic and the design model which is specific to an implementation technology.  Once coding begins, the analysis and design 
				models become obsolete artifacts that are rarely re-iterated over to keep pace with evolution of the implementation model (code).  In the 
				MDA approach, the PIM (analysis model) becomes the central artifact in development.  From it, the PSM is generated and thus all development 
				must begin with the PIM.  Any changes to the PIM are subsequently and unavoidably reflected in the generated PSM and associated application code.  
				In this way, modeling (which is too often neglected) becomes a central and necessary part of the development process.  This has the following 
				benefits:
			</p>
			
			<ul>
				<li>
					<p>
						<strong>More intuitive traceability to requirements.</strong>  Since the PIM is at the business level of abstraction, it should be easier for the 
						requirements analysts to determine sufficient coverage of the requirements.
					</p>
				</li>
				<li>
					<p>
						<strong>Faster time to market.</strong>  Since the majority of application code is generated there is typically a productivity boost of at least an order
						of magnitude when employing MDA.  More importantly, developers can focus on business logic that is of utmost importance to customers
						instead of dealing with the tedium of developing things like getters and setters.
					</p>
				</li>
				<li>
					<p>
						<strong>Better software quality.</strong>  By eliminating the majority of human-produced code, generated code is inherently higher 
						quality.  In the even that generated code is sub-optimal the code generation templates can be modified and all generated code 
						will automatically get the benefit of the innovation.
					</p>
				</li>
			</ul>
			
			<h2>Atlas MDA Overview</h2>
			<p>
				In the case of Atlas, the PIM is the form of metadata that describes the entities and services in an application.  The Atlas MDA engine is responsible for transforming the metadata into a PSM model.  In this case, the PSM is specific to the 
				<a href="http://java.sun.com">Java</a> programming language.  To be more precise, the PSM is Java-based and sits on top of the atlas-core <em>applistructure</em>.
			</p>
			<p>
				In summary, this means that atlas-core defines the application architecture and atlas-mda transforms the metadata into application code that is based on top of atlas-core.  Atlas-core provides the "plumbing" that is common across functional
				areas while the generated application code is specific to the problem space.
			</p>
			<p>
				<img src="images/mda_overview.jpg" alt=""></img>
			</p>
			
			<h2>Atlas MDA Model</h2>
			<p>
				Atlas is designed to be able to generate applications onto a variety of application frameworks, which may be developed in a variety of 
				programming languages.  Currently the Java programming language is supported using the default atlas-java application framework.  
				Any number of framework	plug-ins may be developed to provide framework level code and the associated code generators.  Examples of framework 
				plug-ins include atlas-hibernate and atlas-spring, which provide implementations of the architectural mechanism interfaces specified in atlas-java.
			</p>
			<p>
				In general, Atlas follows the following model:
				<ul>
					<li>An application is developed in one or more programming languages</li>
					<li>An application is based on an application framework</li>
					<li>A application framework specifies the architectural mechanism interfaces and base classes</li>
					<li>A framework plug-in may be used to specify implementation elements dependent on third-party components.  This allows for loose coupling and plug-ability of architectural mechanisms.  For example, Hibernate for persistency today and EJB3 entities tomorrow without having to change application code</li>
					<li>Frameworks and framework plug-ins specify the code generation targets (templates and generators) that leverage the implementation elements they define</li>
					<li>An application has a profile that specifies what targets to use to generate the implementation elements that compose the application.</li>
				</ul>
			</p>
			<p>
				<img src="images/codegenmodel.jpg" alt=""></img>
			</p>

				

		</div>
	</body>
</html>
